package JDK;

import org.junit.Test;
import 集合.Emp;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

/**
 * 1.Stream的创建
 * 2.Stream的中间操作,中间操作不会执行任何处理，在终止时一次性全部处理，称为”惰性求值“
 * 3.Stream的终止操作,
 */
public class StreamAPI {
    //创建Stream的方式一：通过集合
    //创建Stream的方式二：通过数组
    //创建Stream的方式三：通过Stream的of()
    //创建Stream的方式四：通过无限流
    @Test
    public void test1(){
        List<Emp> emps=Emp.getEmp();
        Stream<Emp> stream = emps.stream();
        Stream<Emp> parallelStream = emps.parallelStream();
    //Stream的中间操作
        //filter(Predicate p)接收,从流中排除某些元素
        stream.filter(e->e.getSalar()>5000).forEach(System.out::println);
        //limit(n)截断流,使元素不超过给定的数量
        emps.stream().limit(3).forEach(System.out::println);
        //skip(n)跳过,从流中跳过某些元素(不足n个时返回空流)
        emps.stream().skip(3).forEach(System.out::println);
        //distinct(n)筛选,从流中去除重复元素(hashCode()+equals()对比去重)
        emps.stream().distinct().forEach(System.out::println);
        //map(Function f)映射,接收一个函数作为参数,将每个符合条件元素转换为其他形式或提取信息并将其映射为新元素
        emps.stream().map(str->str.toString()).forEach(System.out::println);
        //flatMap(Function f)映射,接收一个函数作为参数,将每个符合条件元素转换为另一个流,连接所有的流为一个
        //emps.stream().flatMap(StreamAPI::fromStringToStream).forEach(System.out::println);
        //sorted()自然排序,从小到大,须实现Comparable接口
        emps.stream().sorted().forEach(System.out::println);
        //sorted()定制排序
        emps.stream().sorted((e1,e2)->Integer.compare(e1.getAge(),e2.getAge())).forEach(System.out::println);
    //Stream的终止操作
        //allMatch(Predicate p)判断是否全匹配
        System.out.printf("", emps.stream().allMatch(e -> e.getSalar() > 10000));
        //anyMatch(Predicate p)判断是否至少一个匹配
        System.out.printf("", emps.stream().anyMatch(e -> e.getSalar() > 10000));
        //noneMatch(Predicate p)判断是否不匹配
        System.out.printf("", emps.stream().noneMatch(e -> e.getSalar() > 10000));
        //findFirst()返回第一个元素
        emps.stream().findFirst();
        //findAny()返回任意元素
        emps.stream().findAny();
        //count()返回元素总个数
        emps.stream().count();
        //max/min(Comparator c)返回流中最大/小值
        emps.stream().max((e1,e2)->Integer.compare(e1.getAge(),e2.getAge()));
        //forEach(Consumer c)内部迭代-----外部迭代(Collection接口的迭代)
        emps.stream().forEach(System.out::println);
        //reduce(T identity ,BinaryOperator)/(BinaryOperator)规约,将流中的元素反复结合得到一个值,返回T/Optional<T>
        List<Integer> list = Arrays.asList(1, 2, 8, 54, 64, 56);
        list.stream().reduce(0,Integer::sum);//identity初始值
        //collect(Collector c)收集,将流转换为其他形式,接收一个Collector接口的实现,作为汇总方法
        emps.stream().filter(e -> e.getSalar() > 10000).collect(Collectors.toList()).forEach(System.out::println);//返回一个list集合
    }
    public static Stream<Character> fromStringToStream(String s){
        ArrayList<Character> l = new ArrayList<>();
        for (Character c:s.toCharArray())
            l.add(c);
        return l.stream();
    }
    //通过通过数组
    public void test2(){
        int[] arr=new int[]{9,8,54,1};
        IntStream stream = Arrays.stream(arr);
        Emp emp1 = new Emp("", 1, "", 1);
        Emp[] arr1=new Emp[]{emp1};
        Stream<Emp> stream1 = Arrays.stream(arr1);
    }
    //通过Stream的of()
    public void test3(){
        Stream<Integer> stream=Stream.of(1,85,46,1,63,46);
    }
    //通过无限流
    public void test4(){
        Stream.iterate(0,t->t+2).limit(10).forEach(System.out::println);//迭代、限制、循环
        Stream.generate(Math::random).limit(10).forEach(System.out::println);//生成、限制、循环
    }
}
